<!DOCTYPE html>
<html 
	lang="zh-CN">
	<head>
		<meta charset="UTF-8" />
		<meta http-equiv="X-UA-Compatible" content="IE=edge" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		
<link rel="stylesheet" href="/css/layout.css">

		
		<title> Java基础知识点汇总 -  森屿安年</title>
		<link rel="stylesheet" href="https://unpkg.com/mdui@1.0.2/dist/css/mdui.min.css" />
		<script src="https://unpkg.com/mdui@1.0.2/dist/js/mdui.min.js"></script>
		<!-- lazyload -->
		<script src="https://unpkg.com/lazysizes@5.1.0/lazysizes.min.js"></script>
		<!-- smooth-scrolling -->
		<script src="https://unpkg.com/smooth-scrolling.js@1.0.0"></script>
		<!-- highlight -->
		<link rel="stylesheet" href="//unpkg.com/@highlightjs/cdn-assets@11.6.0/styles/atom-one-dark.min.css" />
		<script src="//unpkg.com/@highlightjs/cdn-assets@11.6.0/highlight.min.js"></script>
		<!-- 预置 kiraicon -->
		
<link rel="stylesheet" href="/lib/iconfont/iconfont.css">

		
		<link
			rel="shortcut icon"
			href="https://picshack.net/ib/HqilSRY4zh.png"
			type="image/png"
		/>
		
<link rel="stylesheet" href="/deps/css/APlayer.min.css">

		
			
				
<link rel="stylesheet" href="/style.css">

			
				
<link rel="stylesheet" href="/custom.css">

			
		
		
<script src="/deps/js/APlayer.min.js"></script>
<script src="/deps/js/Meting.min.js"></script>

	<meta name="generator" content="Hexo 7.0.0"></head>

	<body>
		<div
			class="kira-background"
			style="background-image: url('https://picshack.net/ib/i7qQmtNNm0.jpg')"
		></div>
		<div class="kira-header">
    <a
        class="kira-drawer-button mdui-ripple"
        title="导航栏"
        onclick="document.querySelector('.kira-sidebar-modal').classList.add('show');document.querySelector('.kira-sidebar#sidebar').classList.add('show');"
    >
        <i class="kirafont icon-menu"></i>
    </a>
    <a href="/" title="森屿安年">
        <img
			src="https://picshack.net/ib/HqilSRY4zh.png"
			alt="森屿安年"
		/>
    </a>
</div>
		<div class="kira-body">
			<div class="kira-sidebar" id="sidebar">
	<div class="kira-avatar mdui-ripple">
		<a target="_blank" rel="noopener" href="https://picshack.net/ib/HqilSRY4zh.png" title="森屿安年">
			<img
				src="https://picshack.net/ib/HqilSRY4zh.png"
				alt="森屿安年"
			/>
		</a>
	</div>
	<div class="kira-count">
		<div><span>文章</span>4</div>
		<div><span>标签</span>0</div>
		<div><span>分类</span>0</div>
	</div>
	<div class="kira-list">
		
		<a
			class="kira-list-item mdui-ripple false"
			href="/"
			title="回到首页"
		>
			<i
				class="kirafont
					
						icon-home
					"
			></i>
			<div class="kira-list-item-content">
				回到首页
			</div>
		</a>
		
		<a
			class="kira-list-item mdui-ripple false"
			href="/archive.html"
			title="文章归档"
		>
			<i
				class="kirafont
					
						icon-container
					"
			></i>
			<div class="kira-list-item-content">
				文章归档
			</div>
		</a>
		
		<a
			class="kira-list-item mdui-ripple false"
			href="/about.html"
			title="关于本人"
		>
			<i
				class="kirafont
					
						icon-user
					"
			></i>
			<div class="kira-list-item-content">
				关于本人
			</div>
		</a>
		
		<a
			class="kira-list-item mdui-ripple false"
			href="/friends.html"
			title="我的朋友"
		>
			<i
				class="kirafont
					
						icon-team
					"
			></i>
			<div class="kira-list-item-content">
				我的朋友
			</div>
		</a>
		
	</div>
	<aside id="kira-sidebar">
		
			<div class="kira-widget-wrap">
	<div class="kira-widget kira-social">
		
			<a
				class="mdui-ripple"
				href="https://qm.qq.com/q/8Sew059c0U"
				target="_blank"
				mdui-tooltip="{content: 'QQ'}"
				style="color: rgb(49, 174, 255); background-color: rgba(49, 174, 255, .1);"
			>
				<i
					class="kirafont
					
						icon-QQ
					"
				></i>
			</a>
		
			<a
				class="mdui-ripple"
				href="https://space.bilibili.com/15270310?spm_id_from=333.1007.0.0"
				target="_blank"
				mdui-tooltip="{content: '哔哩哔哩'}"
				style="color: rgb(231, 106, 141); background-color: rgba(231, 106, 141, .15);"
			>
				<i
					class="kirafont
					
						icon-bilibili
					"
				></i>
			</a>
		
			<a
				class="mdui-ripple"
				href="https://github.com/hyperexceed"
				target="_blank"
				mdui-tooltip="{content: 'GitHub'}"
				style="color: rgb(25, 23, 23); background-color: rgba(25, 23, 23, .15);"
			>
				<i
					class="kirafont
					
						icon-github
					"
				></i>
			</a>
		
			<a
				class="mdui-ripple"
				href="https://gitee.com/senyu-annian"
				target="_blank"
				mdui-tooltip="{content: 'Gitee'}"
				style="color: rgb(165, 15, 15); background-color: rgba(165, 15, 15, .15);"
			>
				<i
					class="kirafont
					
						icon-gitee
					"
				></i>
			</a>
		
	</div>
</div>

		
			
		
			

		
	</aside>
	<div class="kira-copyright">
		&copy; 2024
		<a href="/">森屿安年</a>
		Powered by <a href="http://hexo.io/" target="_blank">Hexo</a> &
		<a href="https://github.com/ch1ny/kira-hexo/" target="_blank">Kira-Hexo</a>
		<br />
		
			<a
				href="https://beian.miit.gov.cn/"
				target="_blank"
			>
				赣ICP备******号
			</a>
		
		
	</div>
</div>
<div
	class="kira-sidebar-modal"
	id="sidebar-modal"
	onclick="(function(self) {
		self.classList.remove('show');
		document.querySelector('.kira-sidebar.show#sidebar').classList.remove('show');
	})(this)"
></div>
			<div class="kira-content">
				<div id="kira-top-header"></div>
				<div class="kira-main-content">
					
<link rel="stylesheet" href="/css/kira-image.css">


<script src="/js/kira-image.js"></script>

<div class="kira-image">
    <div class="kira-image-modal">
        <div class="kira-image-header">
            <div class="kira-image-counter"></div>
            <div class="kira-image-title"></div>
            <div class="kira-image-operation">
                <div class="kira-image-operation-button" id="kira-image-operation-button-zoom">
                    <i class="kirafont icon-zoom-in"></i>
                </div>
                <div class="kira-image-operation-button" id="kira-image-operation-button-close">
                    <i class="kirafont icon-close"></i>
                </div>
            </div>
        </div>
        <div class="kira-image-container">
            <div class="kira-image-prev-button-panel">
                <div class="kira-image-exchange-button">
                    <i class="kirafont icon-left"></i>
                </div>
            </div>
            <div class="kira-image-list">
                <div class="kira-image-prev">
                    <img />
                </div>
                <div class="kira-image-now">
                    <img />
                </div>
                <div class="kira-image-next">
                    <img />
                </div>
            </div>
            <div class="kira-image-next-button-panel">
                <div class="kira-image-exchange-button">
                    <i class="kirafont icon-right"></i>
                </div>
            </div>
        </div>
    </div>
</div>
<div class="kira-post">
	<article>
		
		<div
			class="kira-post-cover"
			style="padding-bottom: '56.25%'"
		>
			<img
				data-src="https://picshack.net/ib/i7qQmtNNm0.jpg"
				data-sizes="auto"
				alt="Java基础知识点汇总"
				class="lazyload kira-post-cover-image disabled-kira-image"
			/>
			<h1>Java基础知识点汇总</h1>
		</div>
		
		<div class="kira-post-meta kira-rainbow" style="margin:10px 0!important;">
			<a><i class="kirafont icon-calendar-fill"></i>2024年01月05日</a>
			<a><i class="kirafont icon-edit-fill"></i>6.4k 字</a>
			<a><i class="kirafont icon-time-circle-fill"></i>大概 28 分钟</a>
		</div>
		<h2><span id="一java语法基础">一.Java语法基础</span></h2><h3><span id="1标识符">1.标识符</span></h3><p>类名，对象名，变量名，方法名，类型名，数组名，文件名都可以被称作标识符.</p>
<p>一个合法的标识符应该由数字，字母，下划线”_”或美元符号 “$” 与 “¥”组成，首字符不能是数字,标识符也不能是Java中的关键字(具有特殊含义的，如for,if等)和保留字(const,goto)，并且对大小写敏感.</p>
<p>​	例:</p>
<pre><code class="java">    //错误示范
    int 1a = 1;//首字符是数字
    int float = 2;//使用了Java中的关键字float
    int const = 3;//使用了保留字const
    -----------------------------------
    //大小写敏感
     int a = 1;
    int A = 2;//由于对大小写敏感，所以这两个是不同的变量
</code></pre>
<h2><span id="二数据类型">二.数据类型</span></h2><h4><span id="1基本数据类型">1.基本数据类型</span></h4><table>
<thead>
<tr>
<th align="center">类型名</th>
<th align="center">大小</th>
<th align="center">最小值</th>
<th align="center">最大值</th>
</tr>
</thead>
<tbody><tr>
<td align="center">byte</td>
<td align="center">1字节</td>
<td align="center">-128</td>
<td align="center">127</td>
</tr>
<tr>
<td align="center">short</td>
<td align="center">2字节</td>
<td align="center">-2^15</td>
<td align="center">2^15-1</td>
</tr>
<tr>
<td align="center">int</td>
<td align="center">4字节</td>
<td align="center">-2^31</td>
<td align="center">2^31-1</td>
</tr>
<tr>
<td align="center">long</td>
<td align="center">8字节</td>
<td align="center">-2^63</td>
<td align="center">2^63-1</td>
</tr>
<tr>
<td align="center">char</td>
<td align="center">1字节</td>
<td align="center">-128</td>
<td align="center">127</td>
</tr>
<tr>
<td align="center">float</td>
<td align="center">4字节</td>
<td align="center">IEEE754</td>
<td align="center">IEEE754</td>
</tr>
<tr>
<td align="center">double</td>
<td align="center">8字节</td>
<td align="center">IEEE754</td>
<td align="center">IEEE754</td>
</tr>
<tr>
<td align="center">void</td>
<td align="center">-</td>
<td align="center">-</td>
<td align="center">-</td>
</tr>
</tbody></table>
<p>​	</p>
<p>其中，char类型在定义变量时，可以是汉字和空格，但是不可以什么都不写.</p>
<pre><code class="java">//什么都不写是错误写法 
char a = &#39;&#39;;
//可以是汉字和空格
char b = &#39;狗&#39;;
char c = &#39; &#39;;
</code></pre>
<p>定义浮点数默认情况下是double类型，如果要使用float类型，后方需要加f，float类型的精度比double类型要低。</p>
<pre><code class="java">double n = 3.14;//默认是double
float n2 = 2.33f;//float类型需要在数字后加f
</code></pre>
<p>在Java中定义逻辑型变量时，值只能是true或者false.</p>
<pre><code class="java">boolean x = true;
boolean y = false;
boolean d = 1;//错误写法
</code></pre>
<h3><span id="2引用数据类型">2.引用数据类型</span></h3><p><em>①.数组</em></p>
<p><strong>数组分为二维数组和一维数组</strong></p>
<p>​	其中，一维数组的定义方式为:</p>
<p>​	1.数据类型[]  数组名 &#x3D; new 数据类型[数字的个数];<strong>(使用new是因为数组也是一个对象)</strong></p>
<p>​	2.数据类型[] 数组名 &#x3D; {数字1,数字2};</p>
<p>​	3.数据类型[] 数组名 &#x3D; new 数据类型[]{数字1,数字2})<strong>(这里的方括号都不用写数字个数)</strong></p>
<p>​	<strong>一维数组的长度可以使用.length获取</strong></p>
<p>​	例:</p>
<pre><code class="java">    int[] a = new int[];//第一种
    int[] b = &#123;1,2,3&#125;;//第二种
    int[] c = new int[]&#123;1,2,3&#125;;//第三种
    //获取数组长度
    int d = a.length;
</code></pre>
<p>​	</p>
<p><strong>二维数组可以理解为是几个或一个一维数组的组合。</strong></p>
<p>​	二维数组的定义方式为:</p>
<p>​	1.数据类型[] [] 数组名 &#x3D; new 数据类型[行数] [列数];</p>
<p>​	行数:有几个一维数组  列数:每个一维数组有几个元素</p>
<p>​	2.数据类型[] [] 数组名 &#x3D; {{一维数组1},{一维数组2}};</p>
<p>​	3.数据类型[] [] 数组名 &#x3D; new 数据类型[] [] {{一维数组1},{一维数组2}};<strong>(这种写法和一维数组相同，方括号不用写数字个数)</strong></p>
<p>​	计算二维数组的行数可以使用<u>数组名.length</u>实现–&gt;<strong>直接计算二维数组中一维数组的个数</strong></p>
<p>​	计算列数则是使用<u>数组名[具体行数].length</u>–&gt;<strong>通过获取一维数组再计算一维数组的长度</strong></p>
<p>​	例:</p>
<pre><code class="java">    int[][] a = new int[3][4];//第一种
    int[][] b = &#123;&#123;1,2,3,4&#125;,&#123;2,3,4,5&#125;,&#123;3,4,5,6&#125;&#125;;//第二种
    int[][] c = new int[][]&#123;&#123;1,2,3,4&#125;,&#123;2,3,4,5&#125;,&#123;3,4,5,6&#125;&#125;;//第三种,以上都是三行四列的二维数组
    int row = a.length;//计算行数
     int column = a[0].length;//计算列数
</code></pre>
<table>
<thead>
<tr>
<th align="center"></th>
<th align="center">第一列</th>
<th align="center">第二列</th>
<th align="center">第三列</th>
<th align="center">第四列</th>
</tr>
</thead>
<tbody><tr>
<td align="center">第一行</td>
<td align="center">1</td>
<td align="center">2</td>
<td align="center">3</td>
<td align="center">4</td>
</tr>
<tr>
<td align="center">第二行</td>
<td align="center">2</td>
<td align="center">3</td>
<td align="center">4</td>
<td align="center">5</td>
</tr>
<tr>
<td align="center">第三行</td>
<td align="center">3</td>
<td align="center">4</td>
<td align="center">5</td>
<td align="center">6</td>
</tr>
</tbody></table>
<p>​	</p>
<p><em>②.类</em></p>
<p>​	先简要概括一下类和对象，细节后面再说.</p>
<p>​	类是创建对象的模板，也是对象的抽象，在Java中，类中有许多不同的成员方法和成员变量.</p>
<p>​	对象由类实例化产生，所以对象是类的实例化.</p>
<p>③.接口</p>
<p>​	用于声明一系列方法的措施,是一个抽象类.</p>
<h2><span id="3运算符">3.运算符</span></h2><p>在Java中，运算符分为算数运算符、赋值运算符、比较运算符、位运算符、逻辑运算符和三目运算符</p>
<h5><span id="1算数运算符">1.算数运算符</span></h5><table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">结果</th>
</tr>
</thead>
<tbody><tr>
<td align="center">+</td>
<td align="center">正号</td>
<td align="center">a&#x3D;+3</td>
<td align="center">a&#x3D;3</td>
</tr>
<tr>
<td align="center">-</td>
<td align="center">负号</td>
<td align="center">b&#x3D;4;b&#x3D;-4</td>
<td align="center">-4</td>
</tr>
<tr>
<td align="center">+</td>
<td align="center">加运算</td>
<td align="center">3+4</td>
<td align="center">7</td>
</tr>
<tr>
<td align="center">-</td>
<td align="center">减运算</td>
<td align="center">3-4</td>
<td align="center">-1</td>
</tr>
<tr>
<td align="center">*</td>
<td align="center">乘运算</td>
<td align="center">3*4</td>
<td align="center">12</td>
</tr>
<tr>
<td align="center">&#x2F;</td>
<td align="center">取商运算</td>
<td align="center">3&#x2F;4</td>
<td align="center">0(整形情况)</td>
</tr>
<tr>
<td align="center">%</td>
<td align="center">取余运算</td>
<td align="center">3%4</td>
<td align="center">3</td>
</tr>
<tr>
<td align="center">–(前置)</td>
<td align="center">变量自减1，前置先减后用</td>
<td align="center">a&#x3D;2;a&#x3D;–a;</td>
<td align="center">1</td>
</tr>
<tr>
<td align="center">–(后置)</td>
<td align="center">变量自减1，后置先用后减</td>
<td align="center">a&#x3D;2;a&#x3D;a–;</td>
<td align="center">2</td>
</tr>
<tr>
<td align="center">++(前置)</td>
<td align="center">变量自增1，前置先加后用</td>
<td align="center">a&#x3D;2;a&#x3D;++a;</td>
<td align="center">3</td>
</tr>
<tr>
<td align="center">++(后置)</td>
<td align="center">变量自增1，后置先减后用</td>
<td align="center">a&#x3D;2;a&#x3D;a++;</td>
<td align="center">2</td>
</tr>
<tr>
<td align="center">+(字符串)</td>
<td align="center">字符串拼接</td>
<td align="center">a’+’b’</td>
<td align="center">‘ab’</td>
</tr>
</tbody></table>
<h3><span id="2赋值运算符">2.赋值运算符</span></h3><table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">结果</th>
</tr>
</thead>
<tbody><tr>
<td align="center">&#x3D;</td>
<td align="center">赋值</td>
<td align="center">a&#x3D;2;b&#x3D;a</td>
<td align="center">b&#x3D;2</td>
</tr>
<tr>
<td align="center">+&#x3D;</td>
<td align="center">先加后赋值</td>
<td align="center">a&#x3D;2;a+&#x3D;2;</td>
<td align="center">a&#x3D;4</td>
</tr>
<tr>
<td align="center">-&#x3D;</td>
<td align="center">先减后赋值</td>
<td align="center">a&#x3D;2;a-&#x3D;2;</td>
<td align="center">a&#x3D;0</td>
</tr>
<tr>
<td align="center">*&#x3D;</td>
<td align="center">先乘后赋值</td>
<td align="center">a&#x3D;2;a*&#x3D;2;</td>
<td align="center">a&#x3D;4</td>
</tr>
<tr>
<td align="center">&#x2F;&#x3D;</td>
<td align="center">先取商后赋值</td>
<td align="center">a&#x3D;2;a&#x2F;&#x3D;2;</td>
<td align="center">a&#x3D;1</td>
</tr>
<tr>
<td align="center">%&#x3D;</td>
<td align="center">先取余后赋值</td>
<td align="center">a&#x3D;2;a%&#x3D;1;</td>
<td align="center">a&#x3D;0</td>
</tr>
</tbody></table>
<h3><span id="3比较运算符">3.比较运算符</span></h3><p><em>逻辑运算符判断为假返回false，为真返回true.</em></p>
<table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">返回值</th>
</tr>
</thead>
<tbody><tr>
<td align="center">&#x3D;&#x3D;</td>
<td align="center">判断相等</td>
<td align="center">a&#x3D;2;b&#x3D;2;a&#x3D;&#x3D;b;</td>
<td align="center">true</td>
</tr>
<tr>
<td align="center">&gt;&#x3D;</td>
<td align="center">判断大于等于</td>
<td align="center">a&#x3D;3;b&#x3D;2;a&gt;&#x3D;b;</td>
<td align="center">true</td>
</tr>
<tr>
<td align="center">&lt;&#x3D;</td>
<td align="center">判断小于等于</td>
<td align="center">a&#x3D;3;b&#x3D;2;a&lt;&#x3D;b;</td>
<td align="center">false</td>
</tr>
<tr>
<td align="center">!&#x3D;</td>
<td align="center">判断不等</td>
<td align="center">a&#x3D;3;b&#x3D;2;a!&#x3D;b;</td>
<td align="center">true</td>
</tr>
<tr>
<td align="center">&gt;</td>
<td align="center">判断大于</td>
<td align="center">a&#x3D;3;b&#x3D;2;a&gt;b;</td>
<td align="center">true</td>
</tr>
<tr>
<td align="center">&lt;</td>
<td align="center">判断小于</td>
<td align="center">a&#x3D;3;b&#x3D;2;a&lt;b;</td>
<td align="center">false</td>
</tr>
</tbody></table>
<h3><span id="4位运算符">4.位运算符</span></h3><table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">结果</th>
</tr>
</thead>
<tbody><tr>
<td align="center">&lt;&lt;</td>
<td align="center">将二进制补码向左移动n位(不管正负，直接在后方补0)</td>
<td align="center">a&#x3D;1;a&#x3D;a&lt;&lt;1;</td>
<td align="center">2</td>
</tr>
<tr>
<td align="center">&gt;&gt;</td>
<td align="center">将二进制补码向右移动n位(正数前面补0,负数前面补1)</td>
<td align="center">a&#x3D;1;a&#x3D;a&gt;&gt;1;</td>
<td align="center">0</td>
</tr>
<tr>
<td align="center">&amp;</td>
<td align="center">按位与(1与1为1，其它都是0)</td>
<td align="center">a&#x3D;1;b&#x3D;0;a&#x3D;a&b;</td>
<td align="center">0</td>
</tr>
<tr>
<td align="center">|</td>
<td align="center">按位或(0与0为0，其它都为1)</td>
<td align="center">a&#x3D;1;b&#x3D;0;a&#x3D;a|b;</td>
<td align="center">1</td>
</tr>
<tr>
<td align="center">^</td>
<td align="center">按位异或(相同为0，相异为1)</td>
<td align="center">a&#x3D;1;b&#x3D;0;a&#x3D;a^b;</td>
<td align="center">1</td>
</tr>
<tr>
<td align="center">~</td>
<td align="center">按位取反</td>
<td align="center">a&#x3D;1;a&#x3D;~;</td>
<td align="center">很大的数</td>
</tr>
</tbody></table>
<p><strong>需要注意的是，使用按位取反可以做到替换两个数值的操作</strong></p>
<p>例:</p>
<pre><code class="java">    int a = 4;
    int b = 3;
    a = a ^ b;//相同的两个数字进行^结果是0,0^某个数字结果还是这个数字
    b = a ^ b;//等于a ^ b ^ b = a
    a = a ^ b;//等于a ^ b ^ a = b
</code></pre>
<h3><span id></span></h3><h3><span id="5逻辑运算符">5.逻辑运算符</span></h3><table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">返回值</th>
</tr>
</thead>
<tbody><tr>
<td align="center">&amp;&amp;</td>
<td align="center">逻辑与运算(有一个false就是假)</td>
<td align="center">true&amp;&amp;false</td>
<td align="center">false</td>
</tr>
<tr>
<td align="center">||</td>
<td align="center">逻辑或运算(有一个true就是真)</td>
<td align="center">true||flase</td>
<td align="center">true</td>
</tr>
<tr>
<td align="center">!</td>
<td align="center">逻辑取反</td>
<td align="center">!true</td>
<td align="center">false</td>
</tr>
</tbody></table>
<h3><span id="6三目运算符">6.三目运算符</span></h3><table>
<thead>
<tr>
<th align="center">运算符</th>
<th align="center">运算</th>
<th align="center">例子</th>
<th align="center">结果</th>
</tr>
</thead>
<tbody><tr>
<td align="center">（）？（）：（）</td>
<td align="center">小型判断语句</td>
<td align="center">见下方</td>
<td align="center">a&#x3D;3</td>
</tr>
</tbody></table>
<p>例：</p>
<pre><code class="java">    int a = 2;
    int b = 3;
    a = a&gt;b?a:b;
    //相当于是
    if(a&gt;b)&#123;
        a = a;
    &#125;
    else&#123;
        a = b;
    &#125;
    //所以三目运算符就相当于是小型的if语句
</code></pre>
<h2><span id="四循环语句">四.循环语句</span></h2><p>循环语句主要用于需要重复进行的流程</p>
<p><strong>1.for循环语句</strong></p>
<p>​	for语句适用于比较清楚循环次数的情况.</p>
<p>​	具体格式为:</p>
<pre><code class="java">    for(初始化表达式;条件判断表达式;变量自增/自减表达式)&#123;
        //内部为具体要执行的代码
    &#125;
</code></pre>
<p>​	需要注意的是，for循环的三条语句是可以省略写至其它位置的.</p>
<p>​	例如:</p>
<pre><code class="java">    int a;
    a = 0;//初始化表达式
    for(;;)&#123;
        //条件判断表达式
        if(a &lt; 2)&#123;
            //具体要执行的代码
        &#125;
        //变量自增/自减表达式
        a++;
    &#125;
</code></pre>
<h3><span id="2while循环语句">2.while循环语句</span></h3><p>​	while循环语句适用于不清楚循环次数的情况.</p>
<p>​	具体格式为：</p>
<pre><code class="java">    //while循环的条件判断语句不能为空
    while(条件判断语句)&#123;
        //具体要执行的代码
        //循环变量自增/自减表达式
    &#125;
</code></pre>
<h3><span id></span></h3><h3><span id="3dowhile循环语句">3.do…while循环语句</span></h3><p>​	do…while循环语句不同于for和while的地方是，循环体内的代码会执行一次，再进行条件判断.</p>
<p>​	具体格式为：</p>
<pre><code class="java">    do&#123;
        //具体要执行的代码，不管如何，都会至少执行一次
    &#125;while(条件判断语句);//条件判断语句也不能为空
</code></pre>
<h2><span id="五选择结构语句">五.选择结构语句</span></h2><h3><span id="1if语句">1.if语句</span></h3><p>​	一条if语句的情况(判断一次)：</p>
<pre><code class="java">    if(条件表达式1)&#123;
        //条件表达式1结果为true时，进入if语句
        //结果是false，不进入if语句
    &#125;
</code></pre>
<p>​	多条if语句的情况(用于需要多次判断的时候)：</p>
<pre><code class="java">    if(条件表达式1)&#123;
        
    &#125;
    //两个if语句都会判断一次
    if(条件表达式2)&#123;
        
    &#125;
</code></pre>
<h3><span id="2ifelse语句">2.if…else语句</span></h3><p>​	用于判断两种情况</p>
<p>​	具体格式:	</p>
<pre><code class="java">    if(条件表达式1)&#123;
        //条件表达式1如果为true，进入if语句
    &#125;
    else&#123;
        //条件表达式1如果为false，不进入if,进入else语句
    &#125;
</code></pre>
<h3><span id></span></h3><h3><span id="3ifelse-if语句">3.if…else if语句</span></h3><p>​	也用于判断多种情况，不同于多个if，if…else if只要有一句判断成功，其它的选择语句就不会执行.</p>
<p>​	具体格式:	</p>
<pre><code class="java">    if(条件表达式1)&#123;
        //条件表达式1结果是true进入if语句
        //条件表达式1结果是false不会进入if语句,继续往下
    &#125;	
    else if(条件表达式2)&#123;
        //条件表达式2结果是true进入这个else if语句
        //条件表达式2结果是false不会进入这一个else if语句
    &#125;
    else if(条件表达式3)&#123;
        //条件表达式3结果是true进入这个else if语句
        //条件表达式3结果是false不会进入这一个else if语句
    &#125;
</code></pre>
<h2><span id="六类与对象">六.类与对象</span></h2><p>前面提到过，对象中的成员变量，成员方法等都是来自类，所以，<strong>类是对象的抽象化</strong>.</p>
<p>对象是使用类实例化产生的，所以<strong>对象是类的实例化</strong>.</p>
<p>这里来说说类和对象的细节</p>
<h3><span id="1类的定义">1.类的定义</span></h3><p>​	Java中，可以使用<strong>class关键字</strong>来定义一个类，类中可以定义成员变量和成员方法，并且类名可以被修饰符修饰.</p>
<p>​	具体格式为:</p>
<pre><code class="java">    //定义了一个类A
    [修饰符] class A&#123;
            //成员变量的定义
            [修饰符] 类型名 变量名 [=初始值];
            //成员方法的定义
            [修饰符] 类型名 方法名([参数])&#123;
                //方法体
            &#125;
    
            int a;
            public void output()&#123;
                System.out.println(a);
            &#125;
    &#125;
</code></pre>
<h3><span id="2实例化对象">2.实例化对象</span></h3><p>​	在定义完一个类后，可以通过这个类使用<strong>new关键字</strong>实例化一个或多个对象.</p>
<p>​	也就是说，<strong>一个对象可以有多个引用，而一个引用只能有一个对象</strong>.</p>
<pre><code class="java">    自己定义的类名 引用名(变量名) = new 类名();
    A a = new A();//实例化了一个对象
    A a1 = new A();
    //上面实例化了两个对象，就是实例化了多个对象的表示

    //调用成员方法和成员变量使用 . 操作符
    a.output();//调用了成员方法output
    a.a;//调用了成员变量a(不推荐这样调用)
</code></pre>
<p><img src="https://picshack.net/ib/ycoYq11zZN.png"></p>
<h3><span id="3构造方法">3.构造方法</span></h3><p>构造方法的<strong>名字与类名相同</strong>，并且<strong>没有返回值</strong></p>
<p>在上面进行对象的实例化时，实际上调用了类中的构造方法</p>
<p>编译器在程序员没有写构造方法时，会默认提供一个<strong>不带任何参数的构造方法</strong></p>
<p>例：</p>
<pre><code class="java">    public class A&#123;
        //这是一个不带参数的构造方法
        //没有任何返回值
        public A()&#123;
            
        &#125;
    &#125; 
    public class Practice()&#123;
        public static void main(String[] args)&#123;
              //这里的A()实际上就是一个不带任何参数的构造方法
                A a = new A();   
        &#125;
    &#125;
</code></pre>
<p><strong>构造方法一般用来对类的成员变量进行初始化</strong></p>
<p>如果想要使用带参数的构造方法，只需要定义相应的构造方法并在实例化的时候传参即可.</p>
<p>例：</p>
<pre><code class="java">public class A&#123;
    //不带参数的构造方法
    public A()&#123;
        //构造方法可以互相调用,但是不能形成环
        A(1);
    &#125;
    //带1个参数的构造方法
    public A(int a)&#123;
        
    &#125;
    //此处两个方法名字相同，参数不同，构成了方法重载
&#125;
public class Practice()&#123;
    public static void main(String[] args)&#123;
        //使用了不带任何参数的构造方法
        A a = new A();
        //使用了带一个参数的构造方法
        A a = new A(1);
    &#125;
&#125;
</code></pre>
<h3><span id="4成员变量和局部变量">4.成员变量和局部变量</span></h3><p><strong>成员变量</strong>就是在成员方法外定义的变量，<strong>作用域为整个类</strong></p>
<p><strong>局部变量</strong>为在成员方法内定义的变量，<strong>作用域为方法的大括号内部</strong></p>
<pre><code class="java">public class B&#123;
    int a;//成员变量a,整个类内都生效
    
    public void output()&#123;
        int b = 0;//局部变量b,只在方法体内生效
    &#125;
&#125;
</code></pre>
<p>成员变量在定义时，编译器会自动给它初始化，而局部变量不会</p>
<p>定义成员变量时可以不用赋值，但是定义局部变量必须赋值.</p>
<p>成员变量具体初始值如下：</p>
<table>
<thead>
<tr>
<th align="center">变量类型</th>
<th align="center">初始值</th>
</tr>
</thead>
<tbody><tr>
<td align="center">字符</td>
<td align="center">‘\u0000’</td>
</tr>
<tr>
<td align="center">整形</td>
<td align="center">0</td>
</tr>
<tr>
<td align="center">float</td>
<td align="center">0.0f</td>
</tr>
<tr>
<td align="center">double</td>
<td align="center">0.0</td>
</tr>
<tr>
<td align="center">boolean</td>
<td align="center">false</td>
</tr>
<tr>
<td align="center">引用类型</td>
<td align="center">null</td>
</tr>
</tbody></table>
<h3><span id="5方法重载">5.方法重载</span></h3><p>在类中定义<strong>方法名字相同</strong>，但是<strong>参数类型不同的方法</strong>，就构成了方法重载.</p>
<p>构造方法也可以构成方法重载.</p>
<p>例：</p>
<pre><code class="java">public class B&#123;
    int a;
    //没有参数，或者说参数类型是void
    public B()&#123;
        
    &#125;
    //有一个int类型的b参数
    public B(int b)&#123;
        
    &#125;
    //参数类型不同，构成方法重载
&#125;
</code></pre>
<h3><span id="6this关键字">6.this关键字</span></h3><p>this关键字是一种特殊的引用，指向了当前对象</p>
<p>可以理解为：</p>
<p><strong>this关键字就代表当前的引用</strong></p>
<p>例：</p>
<pre><code class="java">public class B&#123;
    int a;
    public B()&#123;
        
    &#125;
&#125;

public class Practice()&#123;
     public static void main(String[] args)&#123;
         //如果是b引用，那么this就指向b引用指向的对象
         B b = new B();
         //如果是b2引用，this就指向了b2引用指向的对象
         B b2 = new B();
     &#125;
&#125;
</code></pre>
<p>​	图解：</p>
<p><img src="https://picshack.net/ib/9XdmbDl664.png"></p>
<p><em><strong>this关键字的作用：</strong></em></p>
<p>在变量上，如果成员变量和局部变量名字相同，this关键字就可以分清成员变量和局部变量，具体使用为this.</p>
<p>在方法上，this关键字可以在当前对象的构造方法内调用其它构造方法，具体使用为this(参数);</p>
<p>使用this();调用其它构造方法时，<strong>this必须位于构造方法第一句</strong>.</p>
<p>例：</p>
<pre><code class="java">    public class B&#123;
        int a;
        public B()&#123;
            this(1);//使用this()调用带一个参数且参数类型是整形的构造方法
        &#125;
        public B(int a)&#123;
            this.a = a;//this.区分局部变量和成员变量
        &#125;
    &#125;
</code></pre>
<h3><span id="7static关键字">7.static关键字</span></h3><p>static关键字只能在类中使用</p>
<p>使用static修饰的以下情况：</p>
<p>1.静态成员变量–&gt;<strong>不</strong>隶属于任何一个对象，为所有对象所共用,调用时，要使用<u><strong>类名.</strong></u>的方式.</p>
<p>（如果使用<u><strong>引用.</strong></u>的方式访问，编译器不会报错，但是不推荐这么做）</p>
<p>2.静态成员方法–&gt;<strong>只能使用静态成员变量和其它的静态成员方法</strong></p>
<p>3.静态内部类–&gt;<strong>内部没有隐含的一个引用，只能使用外嵌类的静态成员变量和静态成员方法</strong></p>
<p>(在内部类创建时，会自带一个指向外嵌类的引用，因为有这个引用存在，所以内嵌类可以使用外部类的成员变量和成员方法)</p>
<p>4.静态代码块–&gt;在类形成的时候会<u><strong>先执行</strong></u>静态代码块，后执行普通的代码块，如果有多个静态代码块，会依次执行.</p>
<p><strong>静态成员方法只能使用静态成员变量和静态成员方法，但是实例方法（没有被static修饰的）可以使用静态成员变量和非静态成员变量，成员方法同理.</strong></p>
<pre><code class="java">public class C&#123;
    static int a;//静态成员变量,被所有对象共用
    public static void output()&#123;
        //静态成员方法,只能使用静态成员变量，调用其它静态成员方法
    &#125;
    static class D&#123;
        //静态内部类D
    &#125;
    static&#123;
        //静态代码块，在类形成时先执行,一般用于初始化静态成员变量
        a = 0;
    &#125;
&#125;
public class Practice()&#123;
    public static void main(String[] args)&#123;
        //使用类名.的方式使用静态成员变量
        int b = C.a;
        //使用引用来调用
        C c = new C();
        int d = c.a;//不推荐
    &#125;
&#125;
</code></pre>
<h3><span id="8super关键字">8.super关键字</span></h3><p>当父类被子类继承时，父类的成员变量和成员方法子类可以进行使用（除了Private修饰的）.</p>
<p>但是，父类的成员变量和成员方法是看不见的，如果在子类中又有同名的变量出现，这个时候使用相应变量时使用的会是子类的变量.</p>
<p>要使用父类同名的成员变量，就要使用super–&gt;<strong>super.变量名;</strong></p>
<p>要使用父类的成员方法，格式为：**super.方法名();**（只能在子类的方法内使用）</p>
<p>要使用父类的构造方法，格式为：<strong>super(参数);</strong>—调用时，需要写在子类构造方法内的第一行，类似于this();</p>
<p>如果程序员没有在子类的构造方法首行写super():调用父类的构造方法，编译器默认会生成一个隐藏的super();</p>
<p>例:</p>
<pre><code class="java">public class B&#123;
    int a;
    //不带任何参数的构造方法
    public B()&#123;
        
    &#125;
    public void output()&#123;
        
    &#125;
&#125;
//A类是B类的子类
class A extends B&#123;
    //a变量和父类中a变量名字相同
    int a;
    //使用父类的a变量，用super关键字
    int b = super.a;
   
    public void print()&#123;
           //使用父类的成员方法，使用super关键字，并且只能在子类的方法体内使用
        super.output();
    &#125;

    public B()&#123;
        //使用父类构造方法，super()需要写在子类构造方法的第一句,不写编译器默认生成1个
        super();
    &#125;
&#125;
</code></pre>
<h3><span id="9final关键字">9.final关键字</span></h3><p>1.被final修饰的成员变量，会<strong>变成常量</strong>，不能被更改.</p>
<p>2.被final修饰的父类成员方法，<strong>不能被子类重写</strong>，意为最终版本的方法，防止其它人修改被修饰的方法的含义.</p>
<p>3.被final修饰的类，<strong>不能被其他类继承</strong>，并且其中的成员方法会被编译器改为final型.</p>
<p>例：</p>
<pre><code class="java">//final修饰的类C不能被继承,同时内部的成员方法都会被改为final类型
public final class C&#123;
    final int a;//成员变量a被final修饰，为常量,不能更改
    public final void output()&#123;
        //成员方法output被final修饰,不能被子类重写
    &#125;
&#125;
</code></pre>
<h3><span id="10abstract类抽象类">10.abstract类（抽象类）</span></h3><p>被abstract关键字修饰的类，被称作抽象类.</p>
<p>在抽象类中，可以有非抽象方法和抽象方法.</p>
<p>在抽象类中，抽象方法只能定义，没有方法体，并不确定具体的方法功能，并且在未实现前不会开辟在栈上的空间.</p>
<p>因为抽象类不清楚具体的功能，所以抽象类不能被实例化.</p>
<p>当父类被子类继承时，子类需要实现父类中的所有抽象方法.</p>
<p>具体语法格式：</p>
<pre><code class="java">    //抽象类
    [修饰符] abstract class 类名&#123;
            //抽象方法,没有方法体，只是一个声明，不知道具体用处是什么
            [修饰符] abstract 返回值类型 方法名(参数);
    &#125;

    //抽象类C
    public abstract class C&#123;
        //抽象方法
        public abstract void fun();
    &#125;
    //子类D
    class D extends C&#123;
        //实现父类中的所有抽象方法
        public void fun()&#123;
            
        &#125;
    &#125;
</code></pre>
<h2><span id="七面向对象编程的三大特性">七.面向对象编程的三大特性</span></h2><h3><span id="1封装">1.封装</span></h3><p>这个概念类似于生活中的包裹，为了将许多物品打包在一起，通常会需要一个容器，有了这个容器我们才可以将物品整理到一起.</p>
<p>在<strong>面向对象编程</strong>中，<strong>封装就是将各种成员变量和成员方法打包的过程，也就是定义类的过程.</strong></p>
<p>例：</p>
<pre><code class="java">//定义了一个类A，这其实就是在进行封装
public class A&#123;
    //......
&#125;
</code></pre>
<h3><span id="2继承">2.继承</span></h3><p>在生活中，一个父亲通常会有一个或几个孩子，这些孩子都具有父亲的一定特征，这就是继承.</p>
<p>在面向对象编程中具体体现为：一个类使用<strong>extends关键字</strong>继承另外一个类的成员变量，成员方法，那么被继承的那方就被称为父类，继承的那方就是子类，子类能够使用父类的一些成员变量和成员方法（被final关键字修饰的除外），<strong>一个子类只能有一个父类</strong>.</p>
<p>例：</p>
<pre><code class="java">public class A&#123;
    int a;
    public void output()&#123;
        
    &#125;
&#125;
//B类使用extends关键字继承A类
class B extends A&#123;
    
&#125;
</code></pre>
<h3><span id="3多态">3.多态</span></h3><p>指一个事物的多种形态.</p>
<p>具体体现为：继承，接口实现，方法重写，上转型</p>
<p>上转型指父类引用指向子类的对象，可以使用**父类引用.**来调用子类中重写的父类成员方法，如果没有重写，则会直接调用父类的成员方法.</p>
<p>例：</p>
<pre><code class="java">public class B&#123;
    int a;
    public void output()&#123;
    
    &#125;
&#125;
//C类继承了B类
class C extends B&#123;
    //对B类的方法重写
    public void output()&#123;
        
    &#125;
&#125;

public class Practice&#123;
    public static void main(String[] args)&#123;
        //父类引用指向子类对象--上转型
        //父类型 引用名 = new 子类构造方法;
        B b = new C();
        //父类引用.调用子类中重写的父类成员方法
        b.output();
    &#125;
&#125;
</code></pre>
<h2><span id="八包">八.包</span></h2><p>在Java中，包其实就是一个文件夹.</p>
<h3><span id="1包的创建">1.包的创建</span></h3><p>具体的创建方式为：</p>
<p><img src="https://picshack.net/ib/jPlamjXgKv.png"></p>
<p>也可以在硬盘内直接新建一个文件夹:</p>
<p><img src="https://picshack.net/ib/zKwwObThP3.png"></p>
<p>可以看到，在编译器内已经有了一个新的包：</p>
<p><img src="https://picshack.net/ib/RsZv97IJJh.png"></p>
<h3><span id="2包的引入">2.包的引入</span></h3><p>要想引入一个包，需要使用import关键字，也就是平常引入Java自带的包的关键字.</p>
<p><strong>引入包时，不能只引入一个包，要引入包内相应的类.</strong></p>
<p>例：</p>
<pre><code class="java">import java.util.Scanner;//引入了Java自带的util包下的Scanner类
import java.util.*;//引入了util包下的所有类，但是只有在使用时，有关的类才会生效
import java.util;//只引入了util包，是错误的写法
</code></pre>
<p>使用import语句，同样可以引入自己创建的包.</p>
<p>具体语法格式为：</p>
<pre><code class="java">import 自己创建的包的名字.包内的类名;
</code></pre>
<p><em><strong>使用包中的类的成员方法和成员变量有两种情况</strong></em></p>
<p>(1).如果被static修饰，由于它们不隶属于任何一个对象，可以直接通过**类名.**的方式来访问.</p>
<p>(2).没有被static修饰，就需要进行对象的实例化，再调用相应方法.</p>
<h2><span id="九访问修饰符">九.访问修饰符</span></h2><table>
<thead>
<tr>
<th align="center">修饰符</th>
<th align="center">访问权限</th>
<th align="center">继承性</th>
</tr>
</thead>
<tbody><tr>
<td align="center">private</td>
<td align="center">只在当前类内部可以使用</td>
<td align="center">可以被同一个包下的子类继承但是不能使用</td>
</tr>
<tr>
<td align="center">default</td>
<td align="center">只能在同一个包内使用</td>
<td align="center">可以被同一个包下的子类继承并且使用</td>
</tr>
<tr>
<td align="center">protected</td>
<td align="center">能够被跨包的子类访问</td>
<td align="center">可以被不同包的子类继承并且使用</td>
</tr>
<tr>
<td align="center">public</td>
<td align="center">所有情况都可以访问</td>
<td align="center">所有情况都可以继承</td>
</tr>
</tbody></table>
<p><strong>需要注意的是，default修饰符指什么修饰符都不写.</strong></p>
<p>例：</p>
<pre><code class="java">//类C为default修饰
class C&#123;

&#125;
</code></pre>
<h2><span id="十接口">十.接口</span></h2><p>抽象类中可以有非抽象方法和抽象方法，但是在接口中只能有抽象方法，所以<strong>接口是一个比抽象类还要更加抽象的类</strong>.</p>
<p>在接口中方法默认带有abstract修饰符，所以接口中的方法都是抽象方法，如果有一个类要去实现接口，必须<strong>实现接口内提到的所有成员方法</strong>，并且方法<u>不能有final或static关键字</u>，因为接口中的方法就是用于给其他类实现的.</p>
<p>在接口中，变量默认被<strong>public static final修饰</strong>，所以是常量.</p>
<h3><span id="1接口的定义">1.接口的定义</span></h3><p>接口的定义格式：</p>
<pre><code class="java">[修饰符] interface 接口名&#123;
    
&#125;
</code></pre>
<h3><span id="2接口的实现">2.接口的实现</span></h3><p>要想实现接口，需要用到<strong>implements关键字</strong></p>
<p>例：</p>
<pre><code class="java">//接口A
public interface A&#123;
    //接口中的抽象方法,由于是抽象方法，所以不能有方法体，只是一个声明.
    void output();
    void input();
    //接口中的常量
    int a;
&#125;

//实现接口A的类B
public class B implements A&#123;
    //需要实现接口中的所有方法
    public void output()&#123;
        
    &#125;
    public void input()&#123;
        
    &#125;
&#125;
</code></pre>
<h3><span id="3接口的继承">3.接口的继承</span></h3><p>接口同类一样，父类接口可以被子类继承，子类继承的是接口中的<strong>常量和方法声明</strong>.</p>
<pre><code class="java">public interface A&#123;
    
&#125;
//继承了父类接口B的子类接口A
public interface B extends A&#123;
    
&#125;
</code></pre>
<h3><span id="4用接口实例化对象">4.用接口实例化对象</span></h3><p>用接口来实例化实现接口的类的对象时，接口的引用指向了这个对象，类似于上转型.</p>
<p>可以用接口类型的引用来调用对象的方法.</p>
<p>例：</p>
<pre><code class="java">public interface A&#123;
    //声明抽象方法
    void output();
&#125;
public class B implements A&#123;
    //实现接口中的所有抽象方法
    public void output()&#123;
        
    &#125;
&#125;
public class Practice&#123;
    public static void main(String[] args)&#123;
        //接口引用指向对象
        A a = new B();
    &#125;
&#125;
</code></pre>

	</article>

	 
    <div class="kira-post-copyright">
        <strong>本文作者：</strong>森屿安年<br>
        <strong>本文链接：</strong><a href="https://senyu-annian.gitee.io/2024/01/05/java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86%E7%82%B9/" title="https:&#x2F;&#x2F;senyu-annian.gitee.io&#x2F;2024&#x2F;01&#x2F;05&#x2F;java基础知识点&#x2F;" target="_blank" rel="noopener">https:&#x2F;&#x2F;senyu-annian.gitee.io&#x2F;2024&#x2F;01&#x2F;05&#x2F;java基础知识点&#x2F;</a><br>
        
            <strong>版权声明：</strong>本文采用 <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/cn/deed.zh" target="_blank">CC BY-NC-SA 3.0 CN</a> 协议进行许可
        
    </div>

  
	<div class="kira-post-nav">
		<nav class="post-nav">
			
		</nav>
	</div>
	
	<div class="kira-post-meta kira-rainbow">
		
		
	</div>
	
		
<script src="/js/kira-code-copy.js"></script>

	
	
	<div class="kira-post-footer">
		

		
	<div class="giscus"></div>
  
    <script src="https://giscus.app/client.js"
      data-repo="ch1ny/ch1ny.github.io"
      data-repo-id="R_kgDOHGgizw"
      data-category="General"
      data-category-id="DIC_kwDOHGgiz84CU88t"
      data-mapping="pathname"
      data-strict="0"
      data-reactions-enabled="1"
      data-emit-metadata="0"
      data-input-position="top"
      data-theme="light"
      data-lang="en"
      data-loading="lazy"
      crossorigin="anonymous"
      async  
    ></script>
  

	</div>
	
</div>

				</div>
			</div>
			<div class="kira-right-column">
	<a onclick="document.querySelector('#kira-top-header').scrollIntoView({behavior: 'smooth'});" class="kira-backtotop" aria-label="回到顶部" title="回到顶部">
		<button class="mdui-fab mdui-ripple">
			<i class="kirafont icon-caret-up"></i>
		</button>
	</a>
</div>

		</div>
	</body>
</html>
